package com.framework.loippi.utils;

import java.io.BufferedInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.util.LinkedList;
import java.util.List;

/**	文件处理
*  创建人：wangcj
 */
public class FileUtil {

	
	/**获取文件大小 返回 KB 保留3位小数  没有文件时返回0
	 * @param filepath 文件完整路径，包括文件名
	 * @return
	 */
	public static Double getFilesize(String filepath){
		File backupath = new File(filepath);
		return Double.valueOf(backupath.length())/1000.000;
	}
	
	/**
	 * 创建目录
	 * @param destDirName目标目录名
	 * @return 
	 */
	public static Boolean createDir(String destDirName) {
		File dir = new File(destDirName);
		if(!dir.getParentFile().exists()){				//判断有没有父路径，就是判断文件整个路径是否存在
			return dir.getParentFile().mkdirs();		//不存在就全部创建
		}
		return false;
	}

	/**
	 * 删除文件
	 * @param filePathAndName
	 *            String 文件路径及名称 如c:/fqf.txt
	 * @param fileContent
	 *            String
	 * @return boolean
	 */
	public static void delFile(String filePathAndName) {
		try {
			String filePath = filePathAndName;
			filePath = filePath.toString();
			java.io.File myDelFile = new java.io.File(filePath);
			myDelFile.delete();
		} catch (Exception e) {
			System.out.println("删除文件操作出错");
			e.printStackTrace();
		}
	}

	/**
	 * 读取到字节数组0
	 * @param filePath //路径
	 * @throws IOException
	 */
	public static byte[] getContent(String filePath) throws IOException {
		File file = new File(filePath);
		long fileSize = file.length();
		if (fileSize > Integer.MAX_VALUE) {
			System.out.println("file too big...");
			return null;
		}
		FileInputStream fi = new FileInputStream(file);
		byte[] buffer = new byte[(int) fileSize];
		int offset = 0;
		int numRead = 0;
		while (offset < buffer.length
				&& (numRead = fi.read(buffer, offset, buffer.length - offset)) >= 0) {
			offset += numRead;
		}
		// 确保所有数据均被读取
		if (offset != buffer.length) {
			throw new IOException("Could not completely read file " + file.getName());
		}
		fi.close();
		return buffer;
	}

	/**
	 * 读取到字节数组1
	 * 
	 * @param filePath
	 * @return
	 * @throws IOException
	 */
	public static byte[] toByteArray(String filePath) throws IOException {

		File f = new File(filePath);
		if (!f.exists()) {
			throw new FileNotFoundException(filePath);
		}
		ByteArrayOutputStream bos = new ByteArrayOutputStream((int) f.length());
		BufferedInputStream in = null;
		try {
			in = new BufferedInputStream(new FileInputStream(f));
			int buf_size = 1024;
			byte[] buffer = new byte[buf_size];
			int len = 0;
			while (-1 != (len = in.read(buffer, 0, buf_size))) {
				bos.write(buffer, 0, len);
			}
			return bos.toByteArray();
		} catch (IOException e) {
			e.printStackTrace();
			throw e;
		} finally {
			try {
				in.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
			bos.close();
		}
	}

	/**
	 * 读取到字节数组2
	 * 
	 * @param filePath
	 * @return
	 * @throws IOException
	 */
	public static byte[] toByteArray2(String filePath) throws IOException {
		File f = new File(filePath);
		if (!f.exists()) {
			throw new FileNotFoundException(filePath);
		}
		FileChannel channel = null;
		FileInputStream fs = null;
		try {
			fs = new FileInputStream(f);
			channel = fs.getChannel();
			ByteBuffer byteBuffer = ByteBuffer.allocate((int) channel.size());
			while ((channel.read(byteBuffer)) > 0) {
				// do nothing
				// System.out.println("reading");
			}
			return byteBuffer.array();
		} catch (IOException e) {
			e.printStackTrace();
			throw e;
		} finally {
			try {
				channel.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
			try {
				fs.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * Mapped File way MappedByteBuffer 可以在处理大文件时，提升性能
	 * 
	 * @param filename
	 * @return
	 * @throws IOException
	 */
	public static byte[] toByteArray3(String filePath) throws IOException {

		FileChannel fc = null;
		RandomAccessFile rf = null;
		try {
			rf = new RandomAccessFile(filePath, "r");
			fc = rf.getChannel();
			MappedByteBuffer byteBuffer = fc.map(MapMode.READ_ONLY, 0,
					fc.size()).load();
			//System.out.println(byteBuffer.isLoaded());
			byte[] result = new byte[(int) fc.size()];
			if (byteBuffer.remaining() > 0) {
				// System.out.println("remain");
				byteBuffer.get(result, 0, byteBuffer.remaining());
			}
			return result;
		} catch (IOException e) {
			e.printStackTrace();
			throw e;
		} finally {
			try {
				rf.close();
				fc.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	
	
	/**
     * 根据后缀删除文件
     */
	public static void startDeleteFixedFiles(String filedir, List<String> suffixList) {
		if (null == filedir || "".equals(filedir.trim())) {
			System.out.println("filedir 目录不对！");
			return;
		}
		filedir = filedir.trim();
		if (null == suffixList || suffixList.size() <= 0) {
			System.out.println("suffixList 没有要匹配的后缀！");
			return;
		}
		File f = new File(filedir);
		if (f.isDirectory()) {
			handleFile(f, suffixList);
		} else {
			System.out.println("filedir 必须为目录");
		}
	}
	
	/**
     * 根据后缀返回文件名列表
     */
	public static List<String> getFileNames(String filedir, List<String> suffixList) {
		if (null == filedir || "".equals(filedir.trim())) {
			System.out.println("filedir 目录不对！");
			return null;
		}
		filedir = filedir.trim();
		if (null == suffixList || suffixList.size() <= 0) {
			System.out.println("suffixList 没有要匹配的后缀！");
			return null;
		}
		File f = new File(filedir);
		List<String> fileNameList= new LinkedList<String>();
		if (f.isDirectory()) {
			// 目录
			File[] files = f.listFiles();
			for (File subFile : files) {
				fileNameList.add(subFile.getName());
			}
		} else {
			System.out.println("filedir 必须为目录");
		}
		return fileNameList;
	}

	private static void handleFile(File filedir, List<String> suffixList) {
		// 目录
		File[] files = filedir.listFiles();
		for (File subFile : files) {
			if (subFile.isDirectory()) {
				handleFile(subFile, suffixList);
			} else {
				// 文件
				for (String suffix : suffixList) {
					if (subFile.getName().endsWith(suffix)) {
						// 匹配到的要删除
						try {
							subFile.delete();
							System.out.println("已删除文件：" + subFile.getAbsolutePath() + "\\" + subFile.getName());
						} catch (Exception e) {
							System.out.println("文件删除失败：" + subFile.getAbsolutePath() + "\\" + subFile.getName());
						}
					}
				}
			}
		}
	}
	
	/**
	 * @Description: 复制文件  
	 * @param: @param src 源文件
	 * @param: @param target   目标   
	 * @return: void      
	 * @throws
	 */
    public static void copyFile(String src,String target)  
    {     
       File srcFile = new File(src);    
       File targetFile = new File(target); 
       File targetDir = new File(target.substring(0, target.lastIndexOf("\\")+1)); 
       if(!targetDir.exists()){
    	   targetDir.mkdirs();
       }
       InputStream in = null;    
       OutputStream out = null;    
       try {    
           in = new FileInputStream(srcFile);     
           out = new FileOutputStream(targetFile);    
           byte[] bytes = new byte[1024];    
           int len = -1;    
           while((len=in.read(bytes))!=-1)  
           {    
               out.write(bytes, 0, len);    
           }    
           in.close();    
           out.close();    
       } catch (Exception e) {    
       }finally {
    	   try {
    		   if(null != in){
    			   in.close();
    		   }
    		   if(null != out){
    			   out.close();
    		   }
			} catch (IOException e) {
			}    
          
       }    
    } 
    
    /*public static void main(String[] args)  
    {  
        String src="E:DesktopFile\\Android\\CSDN.jpg";  
       // String target="E:/DesktopFile/Android/test/CSDN.jpg";  
       // copyFile(src,target); 
        System.out.println(src.substring(0,src.lastIndexOf("\\")+1));
    } */

}